home *** CD-ROM | disk | FTP | other *** search
/ NeXT Education Software Sampler 1992 Fall / NeXT Education Software Sampler 1992 Fall.iso / Programming / Source / WAIS / ir / sersrch.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-02-02  |  10.8 KB  |  380 lines
  1. /* WIDE AREA INFORMATION SERVER SOFTWARE
  2.    No guarantees or restrictions.  See the readme file for the full standard
  3.    disclaimer.    
  4.    Brewster@think.com
  5. */
  6.  
  7.  
  8. /* implements the search part of irext.h 
  9.    (search_word and finished_search_word)
  10.    -brewster
  11.  
  12. Split from irsearch.c
  13.  
  14.    5/31/91 Added scale_scores.  Fixed document_score_array to long.
  15.    7/8/91 Removed scale_scores, handled in search_word with doc_id > 0.
  16.  
  17.    - Jonny G
  18.  */
  19.  
  20. #include "cdialect.h"
  21. #include "irfiles.h"
  22. #include "irsearch.h"
  23. #include "irext.h"
  24. #include <string.h>
  25.  
  26. /*===========================*
  27.  *===  Setting Paramters  ===*
  28.  *===========================*/
  29.  
  30. long max_hit_retrieved = 0;
  31.  
  32. long set_query_parameter (mask, parameters)
  33.      long mask;
  34.      query_parameter_type * parameters;
  35. {
  36.   switch (mask)
  37.     {
  38.     case SET_MAX_RETRIEVED_MASK:
  39.       max_hit_retrieved = parameters->max_hit_retrieved;
  40.       break;
  41.     default:
  42.       break;
  43.     }
  44. }
  45.  
  46. /*==============================*
  47.  *===  Document Score Array  ===*
  48.  *==============================*/
  49.  
  50. long *document_score_array = NULL;
  51. long document_score_array_len = 0;
  52.  
  53. /* make_document_score_array insures that the document_score_array
  54.    array is long enough, if not it makes it long enough */
  55. static void make_document_score_array _AP((long length));
  56. static void make_document_score_array(length)
  57. long length;
  58. {
  59.   if(length <= document_score_array_len)
  60.     return;
  61.   /* we have to make a new one.  free the old one first (if any) */
  62.   if(document_score_array != 0){
  63.     s_free(document_score_array);
  64.   }
  65.   document_score_array = (long*)s_malloc(
  66.                      (size_t)(length * sizeof(long)));
  67.   document_score_array_len = length;
  68. }
  69.  
  70. static void destroy_document_score_array _AP((void));
  71. static void destroy_document_score_array()
  72. {
  73.   s_free(document_score_array);
  74.   document_score_array_len = 0;
  75. }
  76.     
  77. void clear_document_score_array()
  78. /* side effects the document_score_array.  XXX could use memset */
  79. { 
  80.   memset(document_score_array, 0, 
  81.      document_score_array_len * sizeof(long));
  82. }
  83.  
  84. /* for debugging purposes */
  85. void print_document_score_array(start,stop)
  86. unsigned long start;
  87. unsigned long stop;
  88. /* assumes start >= 0, stop < db->doc_table_allocated_entries */
  89. {
  90.     long i;
  91.     for(i = start; i <= stop; i++){
  92.         printf("entry number %d: %d \n", 
  93.                i, (unsigned char)document_score_array[i]);
  94.     }
  95. }
  96.  
  97.  
  98.  
  99. /*=========================*
  100.  *===  Best Hits Array  ===*
  101.  *=========================*/
  102.  
  103. hit *best_hits_array = NULL;
  104. long best_hits_array_len = 0;
  105. long current_best_hit = 0;
  106.  
  107. /* make_best_hits_array insures that the best_hits_array
  108.    array is long enough, if not it makes it long enough */
  109. static void make_best_hits_array _AP((long length));
  110. static void make_best_hits_array(length)
  111. long length;
  112. {
  113.   if(length <= best_hits_array_len)
  114.     return;
  115.   /* we have to make a new one.  free the old one first (if any) */
  116.   if(best_hits_array != 0){
  117.     s_free(best_hits_array);
  118.   }
  119.   best_hits_array = (hit*)s_malloc((size_t)(length * sizeof(hit)));
  120.   best_hits_array_len = length;
  121. }
  122.  
  123. static void destroy_best_hits_array _AP((void));
  124. static void destroy_best_hits_array()
  125. {
  126.   s_free(best_hits_array);
  127.   best_hits_array_len = 0;
  128. }
  129.     
  130. void clear_best_hits_array()
  131. /* side effects the best_hits_array.  XXX could use memset */
  132. { 
  133.   memset((char*)best_hits_array, 0, best_hits_array_len * sizeof(hit));
  134. }
  135.  
  136. /* for debugging purposes */
  137. void print_best_hits()
  138. {
  139.   long i;
  140.   for( i = 0; i < best_hits_array_len; i++){
  141.     if (best_hits_array[i].weight != 0)
  142.       { printf("Best hit %ld: weight %ld, doc_id %ld, headline %s, filename %s, lines %ld\n", 
  143.            i, best_hits_array[i].weight, 
  144.            best_hits_array[i].document_id,
  145.            best_hits_array[i].headline,
  146.            best_hits_array[i].filename,
  147.            best_hits_array[i].number_of_lines);
  148.       }
  149.   }
  150. }
  151.  
  152. void sort_best_hits(db)
  153.      database * db;
  154. {
  155.   /* returns nothing.
  156.    * side effects best_hits and document_score_array
  157.    */
  158.  
  159.   long i, doc;
  160.   long worst_weight_to_make_it = 0;
  161.   document_table_entry doc_entry;
  162.   long best_hit_number = 0;
  163.  
  164.   /* snuff the scores */
  165.   for(i = 0; i < max_hit_retrieved; i++){
  166.     best_hits_array[i].weight = 0;
  167.   }
  168.  
  169.   /* loop over the doc, and keep the doc_id and weight in best hit table */
  170.   for(doc = 0; doc < db->doc_table_allocated_entries; doc++){
  171.     long weight = document_score_array[doc];
  172.     if(worst_weight_to_make_it < weight){
  173.       /* merge it into the best_hits array. start at the bottom */
  174.       for(i = (max_hit_retrieved - 1); i >= 0; i--){
  175.     if(weight > best_hits_array[i].weight 
  176.        /* && (check_document_id(doc, db) == true) too slow.*/
  177.        ){
  178.       /* move this entry down */    
  179.       if((i + 1) < max_hit_retrieved){
  180.         best_hits_array[i+1].weight = best_hits_array[i].weight;
  181.         best_hits_array[i+1].document_id = best_hits_array[i].document_id;
  182.       }
  183.       best_hits_array[i].document_id = doc;
  184.         best_hits_array[i].weight = weight;
  185.     }
  186.     else
  187.       break;
  188.       }      
  189.     }
  190.   }
  191.   
  192.   for(i = 0; i < max_hit_retrieved; i++){
  193.     if(best_hits_array[i].weight <= 0)  /* if we are out of good stuff, return */
  194.       return;
  195.     /* fill in the rest of the hit */
  196.     if (read_document_table_entry(&doc_entry,
  197.                   best_hits_array[i].document_id,
  198.                   db) 
  199.     == true){
  200.       best_hits_array[best_hit_number].weight = best_hits_array[i].weight;
  201.       best_hits_array[best_hit_number].document_id = best_hits_array[i].document_id;
  202.       best_hits_array[best_hit_number].start_character = doc_entry.start_character;
  203.       best_hits_array[best_hit_number].end_character = doc_entry.end_character;
  204.       best_hits_array[best_hit_number].document_length = doc_entry.document_length;
  205.       best_hits_array[best_hit_number].number_of_lines = doc_entry.number_of_lines;
  206.       read_filename_table_entry(doc_entry.filename_id, 
  207.                 best_hits_array[best_hit_number].filename,
  208.                 best_hits_array[best_hit_number].type,
  209.                 NULL,
  210.                 db),
  211.       strncpy(best_hits_array[best_hit_number].headline, 
  212.           read_headline_table_entry(doc_entry.headline_id,db),
  213.           MAX_FILE_NAME_LEN);
  214.       best_hit_number++;
  215.     } 
  216.     beFriendly();
  217.   }
  218.   for(i = best_hit_number; i < max_hit_retrieved; i++){
  219.     best_hits_array[best_hit_number].weight = 0;
  220.   }
  221.   /* print_best_hits(s);  for debugging */
  222. }
  223.  
  224.  
  225. /* returns the next best hit */
  226. long best_hit(doc_id, score)
  227.      long *doc_id;    
  228.      long *score;
  229. {
  230.   if(current_best_hit > best_hits_array_len)
  231.     return(1);
  232.   if(best_hits_array[current_best_hit].weight == 0)
  233.     return(1);
  234.   *doc_id = best_hits_array[current_best_hit].document_id;
  235.   *score  = best_hits_array[current_best_hit].weight;
  236.   current_best_hit++;
  237.   return(0);
  238. }
  239.  
  240. long finished_best_hit()
  241. { /* if we are on a small machine, we might want to 
  242.      destroy_document_score_array */
  243.   clear_document_score_array();
  244.   clear_best_hits_array();
  245.   current_best_hit = 0;
  246.   return(0);
  247. }
  248.  
  249. /*=============================*    
  250.  *===  Searching for words  ===*
  251.  *=============================*/
  252.  
  253. long search_word(word,char_pos, line_pos, weight, doc_id, dictionary_value,
  254.          db)
  255.      char *word; /* the word to be searched for */
  256.      long char_pos;        /* the position of the start of the word */
  257.      long line_pos;        /* is this needed? not for signature system */
  258.      long weight;        /* how important the word looks syntactically,
  259.                    such as is it bold */
  260.      long doc_id;        /* current document, seed words is 0,
  261.                    then it increments into the relevant 
  262.                    document */
  263.      long dictionary_value;    /* this is from the disk dictionary,
  264.                    a signature system would use weight,
  265.                    inverted file systems would put
  266.                    position information */
  267.      database *db;
  268. {
  269.   /* this side effects the document_score_array,
  270.    * and downcases the word.
  271.    * Returns 0 if successful or word not present, 
  272.    * returns non-0 if an error.
  273.    *
  274.    */
  275.   
  276.   long not_full_flag = INDEX_BLOCK_FULL_FLAG; /*start out full so it will go on looking */
  277.   long count, index_block_size;
  278.   long internal_document_id, internal_weight, number_of_valid_entries;
  279.   long index_file_block_number = dictionary_value;
  280.   
  281.   FILE *stream = NULL;
  282.   current_best_hit = 0;  /* so that the best hits willstart from 0 */
  283.  
  284.   /* check the document_score_array */
  285.   if(document_score_array_len < db->doc_table_allocated_entries)
  286.     make_document_score_array(db->doc_table_allocated_entries);
  287.  
  288.   if(index_file_block_number >= 0){
  289.     stream = db->index_stream;
  290.     
  291.     while((not_full_flag != INDEX_BLOCK_NOT_FULL_FLAG) && 
  292.       (index_file_block_number != 0)){    
  293.       /* read the index block */
  294.       if (0 != fseek(stream, (long)index_file_block_number, 
  295.              SEEK_SET))    
  296.     { 
  297.       waislog(WLOG_HIGH, WLOG_ERROR, 
  298.           "fseek failed into the inverted file to position %ld",
  299.           (long)index_file_block_number); 
  300.       return(-1);
  301.     }
  302.       
  303.       not_full_flag = read_bytes(INDEX_BLOCK_FLAG_SIZE, stream);
  304.       index_file_block_number = read_bytes(NEXT_INDEX_BLOCK_SIZE, stream);
  305.       index_block_size = read_bytes(INDEX_BLOCK_SIZE_SIZE, stream);
  306.       if(EOF == index_block_size) 
  307.     { 
  308.       waislog(WLOG_HIGH, WLOG_ERROR, 
  309.           "reading from the index file failed");
  310.       return(-1);
  311.     }
  312.       
  313.       if(not_full_flag == INDEX_BLOCK_NOT_FULL_FLAG){
  314.     /* not full */
  315.     number_of_valid_entries = index_file_block_number;
  316.       }
  317.       else if(not_full_flag == INDEX_BLOCK_FULL_FLAG){
  318.     /* full */
  319.     number_of_valid_entries = index_block_size - INDEX_BLOCK_HEADER_SIZE;
  320.       }
  321.       else{            /* bad news, file is corrupted. */
  322.     waislog(WLOG_HIGH, WLOG_ERROR, 
  323.         "Expected the flag in the inverted file to be valid.  it is %ld",
  324.         not_full_flag);
  325.     return(-1);
  326.       }
  327.       /* printf("number of valid bytes: %ld\n", number_of_valid_entries); */
  328.       
  329.       /* add the array to the document_score_array */
  330.       for(count = 0; count < number_of_valid_entries; 
  331.       count = count + INDEX_ELEMENT_SIZE){
  332.     internal_document_id = read_bytes(DOCUMENT_ID_SIZE, stream);
  333.     (void)read_bytes(WORD_POSITION_SIZE, stream);
  334.     (void)read_bytes(CHARACTER_POSITION_SIZE, stream);
  335.     internal_weight = read_bytes(WEIGHT_SIZE,stream);
  336.     /* printf("entry %ld, Doc_id: %ld, weight %ld \n",
  337.         count, internal_document_id, internal_weight); */
  338.     if(EOF == internal_weight) 
  339.       { 
  340.         waislog(WLOG_HIGH, WLOG_ERROR, 
  341.             "reading from the doc-id table failed");
  342.         return(-1);
  343.       }
  344.     if(doc_id > 0) /* we are doing a relevant document */
  345.       internal_weight /= 0.1;
  346.  
  347.     document_score_array[internal_document_id] = 
  348.       document_score_array[internal_document_id] + internal_weight;
  349.       }
  350.     }
  351.     return(0); 
  352.   }
  353.   else if(0 == index_file_block_number){
  354.     /* an error occurred on looking up the word */
  355.     return(-1);
  356.   }
  357.   else                /* index_file_block_number is negative */
  358.     return(0);        /* word not present */
  359. }
  360.  
  361. /* now collect the best hits */
  362. long finished_search_word(db)
  363.      database *db;
  364. { 
  365.   /* check the document_score_array */
  366.   if(document_score_array_len < db->doc_table_allocated_entries)
  367.     make_document_score_array(db->doc_table_allocated_entries);
  368.  
  369.   make_best_hits_array(max_hit_retrieved);
  370.   sort_best_hits(db);
  371.   return(0);
  372. }
  373.  
  374.  
  375.  
  376.  
  377.  
  378.  
  379.  
  380.